package com.daify.threadlearn.chapter01.executorService;

import java.util.concurrent.*;

/**
 * 创建线程池的测试
 * @author daify
 * @date 2019-06-18 16:03
 **/
public class CreateExecutorsTest {

    public ThreadPoolExecutor myExecutor() {
        return new ThreadPoolExecutor(10, 10,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());
    }

    public ThreadPoolExecutor myExecutor2() {
        return new ThreadPoolExecutor(10, 10,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(),
                new MyRejectedExecutionHandler());
    }


    public void getExecutor() {

        // 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
        ExecutorService executorService = Executors.newCachedThreadPool();

        // 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(1);

        // 创建一个定长线程池，支持定时及周期性任务执行
        ScheduledExecutorService scheduledThreadPool = 
                Executors.newScheduledThreadPool(1);

        // 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，
        // 保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。可以实现并发安全中的线程封闭
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

        // 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务
        // 保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
        // 支持定时及周期性任务执行
        ScheduledExecutorService scheduledExecutor = 
                Executors.newSingleThreadScheduledExecutor();

        // 注意此时创建的不再是ThreadPoolExecutor 而是一个ForkJoinPool
        // ForkJoinPool内部维护一个名为WorkQueue的双端队列，使用工作密取来获取其他线程的任务。
        ExecutorService workStealingPool = 
                Executors.newWorkStealingPool();

    }
    
    
    class MyRejectedExecutionHandler implements RejectedExecutionHandler {

        /**
         * 由于达到线程边界和队列容量而阻止执行时要使用的处理程序
         */
        @Override 
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            // do some thing
        }
    }
    
}
